home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / pkgutil.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  10.9 KB  |  491 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import os
  5. import sys
  6. import imp
  7. import os.path as os
  8. from types import ModuleType
  9. __all__ = [
  10.     'get_importer',
  11.     'iter_importers',
  12.     'get_loader',
  13.     'find_loader',
  14.     'walk_packages',
  15.     'iter_modules',
  16.     'ImpImporter',
  17.     'ImpLoader',
  18.     'read_code',
  19.     'extend_path']
  20.  
  21. def read_code(stream):
  22.     import marshal
  23.     magic = stream.read(4)
  24.     if magic != imp.get_magic():
  25.         return None
  26.     
  27.     stream.read(4)
  28.     return marshal.load(stream)
  29.  
  30.  
  31. def simplegeneric(func):
  32.     registry = { }
  33.     
  34.     def wrapper(*args, **kw):
  35.         ob = args[0]
  36.         
  37.         try:
  38.             cls = ob.__class__
  39.         except AttributeError:
  40.             cls = type(ob)
  41.  
  42.         
  43.         try:
  44.             mro = cls.__mro__
  45.         except AttributeError:
  46.             
  47.             try:
  48.                 
  49.                 class cls(cls, object):
  50.                     pass
  51.  
  52.                 mro = cls.__mro__[1:]
  53.             except TypeError:
  54.                 mro = (object,)
  55.             except:
  56.                 None<EXCEPTION MATCH>TypeError
  57.             
  58.  
  59.             None<EXCEPTION MATCH>TypeError
  60.  
  61.         for t in mro:
  62.             if t in registry:
  63.                 return registry[t](*args, **kw)
  64.                 continue
  65.         else:
  66.             return func(*args, **kw)
  67.  
  68.     
  69.     try:
  70.         wrapper.__name__ = func.__name__
  71.     except (TypeError, AttributeError):
  72.         (None, None)
  73.         (None, None)
  74.     except:
  75.         (None, None)
  76.  
  77.     
  78.     def register(typ, func = ((None, None), None)):
  79.         if func is None:
  80.             return (lambda f: register(typ, f))
  81.         
  82.         registry[typ] = func
  83.         return func
  84.  
  85.     wrapper.__dict__ = func.__dict__
  86.     wrapper.__doc__ = func.__doc__
  87.     wrapper.register = register
  88.     return wrapper
  89.  
  90.  
  91. def walk_packages(path = None, prefix = '', onerror = None):
  92.     
  93.     def seen(p, m = { }):
  94.         if p in m:
  95.             return True
  96.         
  97.         m[p] = True
  98.  
  99.     for importer, name, ispkg in iter_modules(path, prefix):
  100.         yield (importer, name, ispkg)
  101.         if ispkg:
  102.             
  103.             try:
  104.                 __import__(name)
  105.             except ImportError:
  106.                 if onerror is not None:
  107.                     onerror(name)
  108.                 
  109.             except Exception:
  110.                 if onerror is not None:
  111.                     onerror(name)
  112.                 else:
  113.                     raise 
  114.             except:
  115.                 onerror is not None
  116.  
  117.             if not getattr(sys.modules[name], '__path__', None):
  118.                 pass
  119.             path = []
  120.             path = _[1]
  121.             for item in walk_packages(path, name + '.', onerror):
  122.                 yield item
  123.                 []
  124.             
  125.         []
  126.     
  127.  
  128.  
  129. def iter_modules(path = None, prefix = ''):
  130.     if path is None:
  131.         importers = iter_importers()
  132.     else:
  133.         importers = map(get_importer, path)
  134.     yielded = { }
  135.     for i in importers:
  136.         for name, ispkg in iter_importer_modules(i, prefix):
  137.             if name not in yielded:
  138.                 yielded[name] = 1
  139.                 yield (i, name, ispkg)
  140.                 continue
  141.         
  142.     
  143.  
  144.  
  145. def iter_importer_modules(importer, prefix = ''):
  146.     if not hasattr(importer, 'iter_modules'):
  147.         return []
  148.     
  149.     return importer.iter_modules(prefix)
  150.  
  151. iter_importer_modules = simplegeneric(iter_importer_modules)
  152.  
  153. class ImpImporter:
  154.     
  155.     def __init__(self, path = None):
  156.         self.path = path
  157.  
  158.     
  159.     def find_module(self, fullname, path = None):
  160.         subname = fullname.split('.')[-1]
  161.         if subname != fullname and self.path is None:
  162.             return None
  163.         
  164.         if self.path is None:
  165.             path = None
  166.         else:
  167.             path = [
  168.                 os.path.realpath(self.path)]
  169.         
  170.         try:
  171.             (file, filename, etc) = imp.find_module(subname, path)
  172.         except ImportError:
  173.             return None
  174.  
  175.         return ImpLoader(fullname, file, filename, etc)
  176.  
  177.     
  178.     def iter_modules(self, prefix = ''):
  179.         if self.path is None or not os.path.isdir(self.path):
  180.             return None
  181.         
  182.         yielded = { }
  183.         import inspect
  184.         filenames = os.listdir(self.path)
  185.         filenames.sort()
  186.         for fn in filenames:
  187.             modname = inspect.getmodulename(fn)
  188.             if modname == '__init__' or modname in yielded:
  189.                 continue
  190.             
  191.             path = os.path.join(self.path, fn)
  192.             ispkg = False
  193.             if not modname and os.path.isdir(path) and '.' not in fn:
  194.                 modname = fn
  195.                 for fn in os.listdir(path):
  196.                     subname = inspect.getmodulename(fn)
  197.                     if subname == '__init__':
  198.                         ispkg = True
  199.                         break
  200.                         continue
  201.                 
  202.             
  203.             if modname and '.' not in modname:
  204.                 yielded[modname] = 1
  205.                 yield (prefix + modname, ispkg)
  206.                 continue
  207.         
  208.  
  209.  
  210.  
  211. class ImpLoader:
  212.     code = None
  213.     source = None
  214.     
  215.     def __init__(self, fullname, file, filename, etc):
  216.         self.file = file
  217.         self.filename = filename
  218.         self.fullname = fullname
  219.         self.etc = etc
  220.  
  221.     
  222.     def load_module(self, fullname):
  223.         self._reopen()
  224.         
  225.         try:
  226.             mod = imp.load_module(fullname, self.file, self.filename, self.etc)
  227.         finally:
  228.             if self.file:
  229.                 self.file.close()
  230.             
  231.  
  232.         return mod
  233.  
  234.     
  235.     def get_data(self, pathname):
  236.         return open(pathname, 'rb').read()
  237.  
  238.     
  239.     def _reopen(self):
  240.         if self.file and self.file.closed:
  241.             mod_type = self.etc[2]
  242.             if mod_type == imp.PY_SOURCE:
  243.                 self.file = open(self.filename, 'rU')
  244.             elif mod_type in (imp.PY_COMPILED, imp.C_EXTENSION):
  245.                 self.file = open(self.filename, 'rb')
  246.             
  247.         
  248.  
  249.     
  250.     def _fix_name(self, fullname):
  251.         if fullname is None:
  252.             fullname = self.fullname
  253.         elif fullname != self.fullname:
  254.             raise ImportError('Loader for module %s cannot handle module %s' % (self.fullname, fullname))
  255.         
  256.         return fullname
  257.  
  258.     
  259.     def is_package(self, fullname):
  260.         fullname = self._fix_name(fullname)
  261.         return self.etc[2] == imp.PKG_DIRECTORY
  262.  
  263.     
  264.     def get_code(self, fullname = None):
  265.         fullname = self._fix_name(fullname)
  266.         if self.code is None:
  267.             mod_type = self.etc[2]
  268.             if mod_type == imp.PY_SOURCE:
  269.                 source = self.get_source(fullname)
  270.                 self.code = compile(source, self.filename, 'exec')
  271.             elif mod_type == imp.PY_COMPILED:
  272.                 self._reopen()
  273.                 
  274.                 try:
  275.                     self.code = read_code(self.file)
  276.                 finally:
  277.                     self.file.close()
  278.  
  279.             elif mod_type == imp.PKG_DIRECTORY:
  280.                 self.code = self._get_delegate().get_code()
  281.             
  282.         
  283.         return self.code
  284.  
  285.     
  286.     def get_source(self, fullname = None):
  287.         fullname = self._fix_name(fullname)
  288.         if self.source is None:
  289.             mod_type = self.etc[2]
  290.             if mod_type == imp.PY_SOURCE:
  291.                 self._reopen()
  292.                 
  293.                 try:
  294.                     self.source = self.file.read()
  295.                 finally:
  296.                     self.file.close()
  297.  
  298.             elif mod_type == imp.PY_COMPILED:
  299.                 if os.path.exists(self.filename[:-1]):
  300.                     f = open(self.filename[:-1], 'rU')
  301.                     self.source = f.read()
  302.                     f.close()
  303.                 
  304.             elif mod_type == imp.PKG_DIRECTORY:
  305.                 self.source = self._get_delegate().get_source()
  306.             
  307.         
  308.         return self.source
  309.  
  310.     
  311.     def _get_delegate(self):
  312.         return ImpImporter(self.filename).find_module('__init__')
  313.  
  314.     
  315.     def get_filename(self, fullname = None):
  316.         fullname = self._fix_name(fullname)
  317.         mod_type = self.etc[2]
  318.         if self.etc[2] == imp.PKG_DIRECTORY:
  319.             return self._get_delegate().get_filename()
  320.         elif self.etc[2] in (imp.PY_SOURCE, imp.PY_COMPILED, imp.C_EXTENSION):
  321.             return self.filename
  322.         
  323.  
  324.  
  325.  
  326. try:
  327.     import zipimport
  328.     from zipimport import zipimporter
  329.     
  330.     def iter_zipimport_modules(importer, prefix = ''):
  331.         dirlist = zipimport._zip_directory_cache[importer.archive].keys()
  332.         dirlist.sort()
  333.         _prefix = importer.prefix
  334.         plen = len(_prefix)
  335.         yielded = { }
  336.         import inspect
  337.         for fn in dirlist:
  338.             if not fn.startswith(_prefix):
  339.                 continue
  340.             
  341.             fn = fn[plen:].split(os.sep)
  342.             if len(fn) == 2 and fn[1].startswith('__init__.py'):
  343.                 if fn[0] not in yielded:
  344.                     yielded[fn[0]] = 1
  345.                     yield (fn[0], True)
  346.                 
  347.             
  348.             if len(fn) != 1:
  349.                 continue
  350.             
  351.             modname = inspect.getmodulename(fn[0])
  352.             if modname == '__init__':
  353.                 continue
  354.             
  355.             if modname and '.' not in modname and modname not in yielded:
  356.                 yielded[modname] = 1
  357.                 yield (prefix + modname, False)
  358.                 continue
  359.         
  360.  
  361.     iter_importer_modules.register(zipimporter, iter_zipimport_modules)
  362. except ImportError:
  363.     pass
  364.  
  365.  
  366. def get_importer(path_item):
  367.     
  368.     try:
  369.         importer = sys.path_importer_cache[path_item]
  370.     except KeyError:
  371.         for path_hook in sys.path_hooks:
  372.             
  373.             try:
  374.                 importer = path_hook(path_item)
  375.             continue
  376.             except ImportError:
  377.                 continue
  378.             
  379.  
  380.         else:
  381.             importer = None
  382.         sys.path_importer_cache.setdefault(path_item, importer)
  383.     except:
  384.         None<EXCEPTION MATCH>ImportError
  385.  
  386.     if importer is None:
  387.         
  388.         try:
  389.             importer = ImpImporter(path_item)
  390.         except ImportError:
  391.             None<EXCEPTION MATCH>ImportError
  392.             None<EXCEPTION MATCH>ImportError
  393.             importer = None
  394.         except:
  395.             None<EXCEPTION MATCH>ImportError<EXCEPTION MATCH>ImportError
  396.         
  397.  
  398.     None<EXCEPTION MATCH>ImportError
  399.     return importer
  400.  
  401.  
  402. def iter_importers(fullname = ''):
  403.     if fullname.startswith('.'):
  404.         raise ImportError('Relative module names not supported')
  405.     
  406.     if '.' in fullname:
  407.         pkg = '.'.join(fullname.split('.')[:-1])
  408.         if pkg not in sys.modules:
  409.             __import__(pkg)
  410.         
  411.         if not getattr(sys.modules[pkg], '__path__', None):
  412.             pass
  413.         path = []
  414.     else:
  415.         for importer in sys.meta_path:
  416.             yield importer
  417.         
  418.         path = sys.path
  419.     for item in path:
  420.         yield get_importer(item)
  421.     
  422.     if '.' not in fullname:
  423.         yield ImpImporter()
  424.     
  425.  
  426.  
  427. def get_loader(module_or_name):
  428.     if module_or_name in sys.modules:
  429.         module_or_name = sys.modules[module_or_name]
  430.     
  431.     if isinstance(module_or_name, ModuleType):
  432.         module = module_or_name
  433.         loader = getattr(module, '__loader__', None)
  434.         if loader is not None:
  435.             return loader
  436.         
  437.         fullname = module.__name__
  438.     else:
  439.         fullname = module_or_name
  440.     return find_loader(fullname)
  441.  
  442.  
  443. def find_loader(fullname):
  444.     for importer in iter_importers(fullname):
  445.         loader = importer.find_module(fullname)
  446.         if loader is not None:
  447.             return loader
  448.             continue
  449.     
  450.  
  451.  
  452. def extend_path(path, name):
  453.     if not isinstance(path, list):
  454.         return path
  455.     
  456.     pname = os.path.join(*name.split('.'))
  457.     sname = os.extsep.join(name.split('.'))
  458.     sname_pkg = sname + os.extsep + 'pkg'
  459.     init_py = '__init__' + os.extsep + 'py'
  460.     path = path[:]
  461.     for dir in sys.path:
  462.         if not isinstance(dir, basestring) or not os.path.isdir(dir):
  463.             continue
  464.         
  465.         subdir = os.path.join(dir, pname)
  466.         initfile = os.path.join(subdir, init_py)
  467.         if subdir not in path and os.path.isfile(initfile):
  468.             path.append(subdir)
  469.         
  470.         pkgfile = os.path.join(dir, sname_pkg)
  471.         if os.path.isfile(pkgfile):
  472.             
  473.             try:
  474.                 f = open(pkgfile)
  475.             except IOError:
  476.                 msg = None
  477.                 sys.stderr.write("Can't open %s: %s\n" % (pkgfile, msg))
  478.  
  479.             for line in f:
  480.                 line = line.rstrip('\n')
  481.                 if not line or line.startswith('#'):
  482.                     continue
  483.                 
  484.                 path.append(line)
  485.             
  486.             f.close()
  487.             continue
  488.     
  489.     return path
  490.  
  491.